/*
 * XML Type:  BankRequestMessageSetV1
 * Namespace: http://ofx.net/types/2003/04
 * Java type: net.ofx.types.x2003.x04.BankRequestMessageSetV1
 *
 * Automatically generated - do not modify.
 */
package net.ofx.types.x2003.x04.impl;
/**
 * An XML BankRequestMessageSetV1(@http://ofx.net/types/2003/04).
 *
 * This is a complex type.
 */
public class BankRequestMessageSetV1Impl extends net.ofx.types.x2003.x04.impl.AbstractRequestMessageSetImpl implements net.ofx.types.x2003.x04.BankRequestMessageSetV1
{
    
    public BankRequestMessageSetV1Impl(org.apache.xmlbeans.SchemaType sType)
    {
        super(sType);
    }
    
    private static final javax.xml.namespace.QName STMTTRNRQ$0 = 
        new javax.xml.namespace.QName("", "STMTTRNRQ");
    private static final javax.xml.namespace.QName STMTENDTRNRQ$2 = 
        new javax.xml.namespace.QName("", "STMTENDTRNRQ");
    private static final javax.xml.namespace.QName INTRATRNRQ$4 = 
        new javax.xml.namespace.QName("", "INTRATRNRQ");
    private static final javax.xml.namespace.QName RECINTRATRNRQ$6 = 
        new javax.xml.namespace.QName("", "RECINTRATRNRQ");
    private static final javax.xml.namespace.QName STPCHKTRNRQ$8 = 
        new javax.xml.namespace.QName("", "STPCHKTRNRQ");
    private static final javax.xml.namespace.QName BANKMAILTRNRQ$10 = 
        new javax.xml.namespace.QName("", "BANKMAILTRNRQ");
    private static final javax.xml.namespace.QName BANKMAILSYNCRQ$12 = 
        new javax.xml.namespace.QName("", "BANKMAILSYNCRQ");
    private static final javax.xml.namespace.QName STPCHKSYNCRQ$14 = 
        new javax.xml.namespace.QName("", "STPCHKSYNCRQ");
    private static final javax.xml.namespace.QName INTRASYNCRQ$16 = 
        new javax.xml.namespace.QName("", "INTRASYNCRQ");
    private static final javax.xml.namespace.QName RECINTRASYNCRQ$18 = 
        new javax.xml.namespace.QName("", "RECINTRASYNCRQ");
    
    
    /**
     * Gets array of all "STMTTRNRQ" elements
     */
    public net.ofx.types.x2003.x04.StatementTransactionRequest[] getSTMTTRNRQArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(STMTTRNRQ$0, targetList);
            net.ofx.types.x2003.x04.StatementTransactionRequest[] result = new net.ofx.types.x2003.x04.StatementTransactionRequest[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "STMTTRNRQ" element
     */
    public net.ofx.types.x2003.x04.StatementTransactionRequest getSTMTTRNRQArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.StatementTransactionRequest target = null;
            target = (net.ofx.types.x2003.x04.StatementTransactionRequest)get_store().find_element_user(STMTTRNRQ$0, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "STMTTRNRQ" element
     */
    public int sizeOfSTMTTRNRQArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(STMTTRNRQ$0);
        }
    }
    
    /**
     * Sets array of all "STMTTRNRQ" element
     */
    public void setSTMTTRNRQArray(net.ofx.types.x2003.x04.StatementTransactionRequest[] stmttrnrqArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(stmttrnrqArray, STMTTRNRQ$0);
        }
    }
    
    /**
     * Sets ith "STMTTRNRQ" element
     */
    public void setSTMTTRNRQArray(int i, net.ofx.types.x2003.x04.StatementTransactionRequest stmttrnrq)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.StatementTransactionRequest target = null;
            target = (net.ofx.types.x2003.x04.StatementTransactionRequest)get_store().find_element_user(STMTTRNRQ$0, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(stmttrnrq);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "STMTTRNRQ" element
     */
    public net.ofx.types.x2003.x04.StatementTransactionRequest insertNewSTMTTRNRQ(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.StatementTransactionRequest target = null;
            target = (net.ofx.types.x2003.x04.StatementTransactionRequest)get_store().insert_element_user(STMTTRNRQ$0, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "STMTTRNRQ" element
     */
    public net.ofx.types.x2003.x04.StatementTransactionRequest addNewSTMTTRNRQ()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.StatementTransactionRequest target = null;
            target = (net.ofx.types.x2003.x04.StatementTransactionRequest)get_store().add_element_user(STMTTRNRQ$0);
            return target;
        }
    }
    
    /**
     * Removes the ith "STMTTRNRQ" element
     */
    public void removeSTMTTRNRQ(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(STMTTRNRQ$0, i);
        }
    }
    
    /**
     * Gets array of all "STMTENDTRNRQ" elements
     */
    public net.ofx.types.x2003.x04.StatementEndTransactionRequest[] getSTMTENDTRNRQArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(STMTENDTRNRQ$2, targetList);
            net.ofx.types.x2003.x04.StatementEndTransactionRequest[] result = new net.ofx.types.x2003.x04.StatementEndTransactionRequest[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "STMTENDTRNRQ" element
     */
    public net.ofx.types.x2003.x04.StatementEndTransactionRequest getSTMTENDTRNRQArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.StatementEndTransactionRequest target = null;
            target = (net.ofx.types.x2003.x04.StatementEndTransactionRequest)get_store().find_element_user(STMTENDTRNRQ$2, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "STMTENDTRNRQ" element
     */
    public int sizeOfSTMTENDTRNRQArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(STMTENDTRNRQ$2);
        }
    }
    
    /**
     * Sets array of all "STMTENDTRNRQ" element
     */
    public void setSTMTENDTRNRQArray(net.ofx.types.x2003.x04.StatementEndTransactionRequest[] stmtendtrnrqArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(stmtendtrnrqArray, STMTENDTRNRQ$2);
        }
    }
    
    /**
     * Sets ith "STMTENDTRNRQ" element
     */
    public void setSTMTENDTRNRQArray(int i, net.ofx.types.x2003.x04.StatementEndTransactionRequest stmtendtrnrq)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.StatementEndTransactionRequest target = null;
            target = (net.ofx.types.x2003.x04.StatementEndTransactionRequest)get_store().find_element_user(STMTENDTRNRQ$2, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(stmtendtrnrq);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "STMTENDTRNRQ" element
     */
    public net.ofx.types.x2003.x04.StatementEndTransactionRequest insertNewSTMTENDTRNRQ(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.StatementEndTransactionRequest target = null;
            target = (net.ofx.types.x2003.x04.StatementEndTransactionRequest)get_store().insert_element_user(STMTENDTRNRQ$2, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "STMTENDTRNRQ" element
     */
    public net.ofx.types.x2003.x04.StatementEndTransactionRequest addNewSTMTENDTRNRQ()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.StatementEndTransactionRequest target = null;
            target = (net.ofx.types.x2003.x04.StatementEndTransactionRequest)get_store().add_element_user(STMTENDTRNRQ$2);
            return target;
        }
    }
    
    /**
     * Removes the ith "STMTENDTRNRQ" element
     */
    public void removeSTMTENDTRNRQ(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(STMTENDTRNRQ$2, i);
        }
    }
    
    /**
     * Gets array of all "INTRATRNRQ" elements
     */
    public net.ofx.types.x2003.x04.IntraTransactionRequest[] getINTRATRNRQArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(INTRATRNRQ$4, targetList);
            net.ofx.types.x2003.x04.IntraTransactionRequest[] result = new net.ofx.types.x2003.x04.IntraTransactionRequest[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "INTRATRNRQ" element
     */
    public net.ofx.types.x2003.x04.IntraTransactionRequest getINTRATRNRQArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.IntraTransactionRequest target = null;
            target = (net.ofx.types.x2003.x04.IntraTransactionRequest)get_store().find_element_user(INTRATRNRQ$4, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "INTRATRNRQ" element
     */
    public int sizeOfINTRATRNRQArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(INTRATRNRQ$4);
        }
    }
    
    /**
     * Sets array of all "INTRATRNRQ" element
     */
    public void setINTRATRNRQArray(net.ofx.types.x2003.x04.IntraTransactionRequest[] intratrnrqArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(intratrnrqArray, INTRATRNRQ$4);
        }
    }
    
    /**
     * Sets ith "INTRATRNRQ" element
     */
    public void setINTRATRNRQArray(int i, net.ofx.types.x2003.x04.IntraTransactionRequest intratrnrq)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.IntraTransactionRequest target = null;
            target = (net.ofx.types.x2003.x04.IntraTransactionRequest)get_store().find_element_user(INTRATRNRQ$4, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(intratrnrq);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "INTRATRNRQ" element
     */
    public net.ofx.types.x2003.x04.IntraTransactionRequest insertNewINTRATRNRQ(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.IntraTransactionRequest target = null;
            target = (net.ofx.types.x2003.x04.IntraTransactionRequest)get_store().insert_element_user(INTRATRNRQ$4, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "INTRATRNRQ" element
     */
    public net.ofx.types.x2003.x04.IntraTransactionRequest addNewINTRATRNRQ()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.IntraTransactionRequest target = null;
            target = (net.ofx.types.x2003.x04.IntraTransactionRequest)get_store().add_element_user(INTRATRNRQ$4);
            return target;
        }
    }
    
    /**
     * Removes the ith "INTRATRNRQ" element
     */
    public void removeINTRATRNRQ(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(INTRATRNRQ$4, i);
        }
    }
    
    /**
     * Gets array of all "RECINTRATRNRQ" elements
     */
    public net.ofx.types.x2003.x04.RecurringIntraTransactionRequest[] getRECINTRATRNRQArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(RECINTRATRNRQ$6, targetList);
            net.ofx.types.x2003.x04.RecurringIntraTransactionRequest[] result = new net.ofx.types.x2003.x04.RecurringIntraTransactionRequest[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "RECINTRATRNRQ" element
     */
    public net.ofx.types.x2003.x04.RecurringIntraTransactionRequest getRECINTRATRNRQArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.RecurringIntraTransactionRequest target = null;
            target = (net.ofx.types.x2003.x04.RecurringIntraTransactionRequest)get_store().find_element_user(RECINTRATRNRQ$6, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "RECINTRATRNRQ" element
     */
    public int sizeOfRECINTRATRNRQArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(RECINTRATRNRQ$6);
        }
    }
    
    /**
     * Sets array of all "RECINTRATRNRQ" element
     */
    public void setRECINTRATRNRQArray(net.ofx.types.x2003.x04.RecurringIntraTransactionRequest[] recintratrnrqArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(recintratrnrqArray, RECINTRATRNRQ$6);
        }
    }
    
    /**
     * Sets ith "RECINTRATRNRQ" element
     */
    public void setRECINTRATRNRQArray(int i, net.ofx.types.x2003.x04.RecurringIntraTransactionRequest recintratrnrq)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.RecurringIntraTransactionRequest target = null;
            target = (net.ofx.types.x2003.x04.RecurringIntraTransactionRequest)get_store().find_element_user(RECINTRATRNRQ$6, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(recintratrnrq);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "RECINTRATRNRQ" element
     */
    public net.ofx.types.x2003.x04.RecurringIntraTransactionRequest insertNewRECINTRATRNRQ(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.RecurringIntraTransactionRequest target = null;
            target = (net.ofx.types.x2003.x04.RecurringIntraTransactionRequest)get_store().insert_element_user(RECINTRATRNRQ$6, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "RECINTRATRNRQ" element
     */
    public net.ofx.types.x2003.x04.RecurringIntraTransactionRequest addNewRECINTRATRNRQ()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.RecurringIntraTransactionRequest target = null;
            target = (net.ofx.types.x2003.x04.RecurringIntraTransactionRequest)get_store().add_element_user(RECINTRATRNRQ$6);
            return target;
        }
    }
    
    /**
     * Removes the ith "RECINTRATRNRQ" element
     */
    public void removeRECINTRATRNRQ(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(RECINTRATRNRQ$6, i);
        }
    }
    
    /**
     * Gets array of all "STPCHKTRNRQ" elements
     */
    public net.ofx.types.x2003.x04.StopCheckTransactionRequest[] getSTPCHKTRNRQArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(STPCHKTRNRQ$8, targetList);
            net.ofx.types.x2003.x04.StopCheckTransactionRequest[] result = new net.ofx.types.x2003.x04.StopCheckTransactionRequest[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "STPCHKTRNRQ" element
     */
    public net.ofx.types.x2003.x04.StopCheckTransactionRequest getSTPCHKTRNRQArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.StopCheckTransactionRequest target = null;
            target = (net.ofx.types.x2003.x04.StopCheckTransactionRequest)get_store().find_element_user(STPCHKTRNRQ$8, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "STPCHKTRNRQ" element
     */
    public int sizeOfSTPCHKTRNRQArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(STPCHKTRNRQ$8);
        }
    }
    
    /**
     * Sets array of all "STPCHKTRNRQ" element
     */
    public void setSTPCHKTRNRQArray(net.ofx.types.x2003.x04.StopCheckTransactionRequest[] stpchktrnrqArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(stpchktrnrqArray, STPCHKTRNRQ$8);
        }
    }
    
    /**
     * Sets ith "STPCHKTRNRQ" element
     */
    public void setSTPCHKTRNRQArray(int i, net.ofx.types.x2003.x04.StopCheckTransactionRequest stpchktrnrq)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.StopCheckTransactionRequest target = null;
            target = (net.ofx.types.x2003.x04.StopCheckTransactionRequest)get_store().find_element_user(STPCHKTRNRQ$8, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(stpchktrnrq);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "STPCHKTRNRQ" element
     */
    public net.ofx.types.x2003.x04.StopCheckTransactionRequest insertNewSTPCHKTRNRQ(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.StopCheckTransactionRequest target = null;
            target = (net.ofx.types.x2003.x04.StopCheckTransactionRequest)get_store().insert_element_user(STPCHKTRNRQ$8, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "STPCHKTRNRQ" element
     */
    public net.ofx.types.x2003.x04.StopCheckTransactionRequest addNewSTPCHKTRNRQ()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.StopCheckTransactionRequest target = null;
            target = (net.ofx.types.x2003.x04.StopCheckTransactionRequest)get_store().add_element_user(STPCHKTRNRQ$8);
            return target;
        }
    }
    
    /**
     * Removes the ith "STPCHKTRNRQ" element
     */
    public void removeSTPCHKTRNRQ(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(STPCHKTRNRQ$8, i);
        }
    }
    
    /**
     * Gets array of all "BANKMAILTRNRQ" elements
     */
    public net.ofx.types.x2003.x04.BankMailTransactionRequest[] getBANKMAILTRNRQArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(BANKMAILTRNRQ$10, targetList);
            net.ofx.types.x2003.x04.BankMailTransactionRequest[] result = new net.ofx.types.x2003.x04.BankMailTransactionRequest[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "BANKMAILTRNRQ" element
     */
    public net.ofx.types.x2003.x04.BankMailTransactionRequest getBANKMAILTRNRQArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.BankMailTransactionRequest target = null;
            target = (net.ofx.types.x2003.x04.BankMailTransactionRequest)get_store().find_element_user(BANKMAILTRNRQ$10, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "BANKMAILTRNRQ" element
     */
    public int sizeOfBANKMAILTRNRQArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(BANKMAILTRNRQ$10);
        }
    }
    
    /**
     * Sets array of all "BANKMAILTRNRQ" element
     */
    public void setBANKMAILTRNRQArray(net.ofx.types.x2003.x04.BankMailTransactionRequest[] bankmailtrnrqArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(bankmailtrnrqArray, BANKMAILTRNRQ$10);
        }
    }
    
    /**
     * Sets ith "BANKMAILTRNRQ" element
     */
    public void setBANKMAILTRNRQArray(int i, net.ofx.types.x2003.x04.BankMailTransactionRequest bankmailtrnrq)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.BankMailTransactionRequest target = null;
            target = (net.ofx.types.x2003.x04.BankMailTransactionRequest)get_store().find_element_user(BANKMAILTRNRQ$10, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(bankmailtrnrq);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "BANKMAILTRNRQ" element
     */
    public net.ofx.types.x2003.x04.BankMailTransactionRequest insertNewBANKMAILTRNRQ(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.BankMailTransactionRequest target = null;
            target = (net.ofx.types.x2003.x04.BankMailTransactionRequest)get_store().insert_element_user(BANKMAILTRNRQ$10, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "BANKMAILTRNRQ" element
     */
    public net.ofx.types.x2003.x04.BankMailTransactionRequest addNewBANKMAILTRNRQ()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.BankMailTransactionRequest target = null;
            target = (net.ofx.types.x2003.x04.BankMailTransactionRequest)get_store().add_element_user(BANKMAILTRNRQ$10);
            return target;
        }
    }
    
    /**
     * Removes the ith "BANKMAILTRNRQ" element
     */
    public void removeBANKMAILTRNRQ(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(BANKMAILTRNRQ$10, i);
        }
    }
    
    /**
     * Gets array of all "BANKMAILSYNCRQ" elements
     */
    public net.ofx.types.x2003.x04.BankMailSyncRequest[] getBANKMAILSYNCRQArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(BANKMAILSYNCRQ$12, targetList);
            net.ofx.types.x2003.x04.BankMailSyncRequest[] result = new net.ofx.types.x2003.x04.BankMailSyncRequest[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "BANKMAILSYNCRQ" element
     */
    public net.ofx.types.x2003.x04.BankMailSyncRequest getBANKMAILSYNCRQArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.BankMailSyncRequest target = null;
            target = (net.ofx.types.x2003.x04.BankMailSyncRequest)get_store().find_element_user(BANKMAILSYNCRQ$12, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "BANKMAILSYNCRQ" element
     */
    public int sizeOfBANKMAILSYNCRQArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(BANKMAILSYNCRQ$12);
        }
    }
    
    /**
     * Sets array of all "BANKMAILSYNCRQ" element
     */
    public void setBANKMAILSYNCRQArray(net.ofx.types.x2003.x04.BankMailSyncRequest[] bankmailsyncrqArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(bankmailsyncrqArray, BANKMAILSYNCRQ$12);
        }
    }
    
    /**
     * Sets ith "BANKMAILSYNCRQ" element
     */
    public void setBANKMAILSYNCRQArray(int i, net.ofx.types.x2003.x04.BankMailSyncRequest bankmailsyncrq)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.BankMailSyncRequest target = null;
            target = (net.ofx.types.x2003.x04.BankMailSyncRequest)get_store().find_element_user(BANKMAILSYNCRQ$12, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(bankmailsyncrq);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "BANKMAILSYNCRQ" element
     */
    public net.ofx.types.x2003.x04.BankMailSyncRequest insertNewBANKMAILSYNCRQ(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.BankMailSyncRequest target = null;
            target = (net.ofx.types.x2003.x04.BankMailSyncRequest)get_store().insert_element_user(BANKMAILSYNCRQ$12, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "BANKMAILSYNCRQ" element
     */
    public net.ofx.types.x2003.x04.BankMailSyncRequest addNewBANKMAILSYNCRQ()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.BankMailSyncRequest target = null;
            target = (net.ofx.types.x2003.x04.BankMailSyncRequest)get_store().add_element_user(BANKMAILSYNCRQ$12);
            return target;
        }
    }
    
    /**
     * Removes the ith "BANKMAILSYNCRQ" element
     */
    public void removeBANKMAILSYNCRQ(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(BANKMAILSYNCRQ$12, i);
        }
    }
    
    /**
     * Gets array of all "STPCHKSYNCRQ" elements
     */
    public net.ofx.types.x2003.x04.StopCheckSyncRequest[] getSTPCHKSYNCRQArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(STPCHKSYNCRQ$14, targetList);
            net.ofx.types.x2003.x04.StopCheckSyncRequest[] result = new net.ofx.types.x2003.x04.StopCheckSyncRequest[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "STPCHKSYNCRQ" element
     */
    public net.ofx.types.x2003.x04.StopCheckSyncRequest getSTPCHKSYNCRQArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.StopCheckSyncRequest target = null;
            target = (net.ofx.types.x2003.x04.StopCheckSyncRequest)get_store().find_element_user(STPCHKSYNCRQ$14, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "STPCHKSYNCRQ" element
     */
    public int sizeOfSTPCHKSYNCRQArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(STPCHKSYNCRQ$14);
        }
    }
    
    /**
     * Sets array of all "STPCHKSYNCRQ" element
     */
    public void setSTPCHKSYNCRQArray(net.ofx.types.x2003.x04.StopCheckSyncRequest[] stpchksyncrqArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(stpchksyncrqArray, STPCHKSYNCRQ$14);
        }
    }
    
    /**
     * Sets ith "STPCHKSYNCRQ" element
     */
    public void setSTPCHKSYNCRQArray(int i, net.ofx.types.x2003.x04.StopCheckSyncRequest stpchksyncrq)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.StopCheckSyncRequest target = null;
            target = (net.ofx.types.x2003.x04.StopCheckSyncRequest)get_store().find_element_user(STPCHKSYNCRQ$14, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(stpchksyncrq);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "STPCHKSYNCRQ" element
     */
    public net.ofx.types.x2003.x04.StopCheckSyncRequest insertNewSTPCHKSYNCRQ(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.StopCheckSyncRequest target = null;
            target = (net.ofx.types.x2003.x04.StopCheckSyncRequest)get_store().insert_element_user(STPCHKSYNCRQ$14, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "STPCHKSYNCRQ" element
     */
    public net.ofx.types.x2003.x04.StopCheckSyncRequest addNewSTPCHKSYNCRQ()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.StopCheckSyncRequest target = null;
            target = (net.ofx.types.x2003.x04.StopCheckSyncRequest)get_store().add_element_user(STPCHKSYNCRQ$14);
            return target;
        }
    }
    
    /**
     * Removes the ith "STPCHKSYNCRQ" element
     */
    public void removeSTPCHKSYNCRQ(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(STPCHKSYNCRQ$14, i);
        }
    }
    
    /**
     * Gets array of all "INTRASYNCRQ" elements
     */
    public net.ofx.types.x2003.x04.IntraSyncRequest[] getINTRASYNCRQArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(INTRASYNCRQ$16, targetList);
            net.ofx.types.x2003.x04.IntraSyncRequest[] result = new net.ofx.types.x2003.x04.IntraSyncRequest[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "INTRASYNCRQ" element
     */
    public net.ofx.types.x2003.x04.IntraSyncRequest getINTRASYNCRQArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.IntraSyncRequest target = null;
            target = (net.ofx.types.x2003.x04.IntraSyncRequest)get_store().find_element_user(INTRASYNCRQ$16, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "INTRASYNCRQ" element
     */
    public int sizeOfINTRASYNCRQArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(INTRASYNCRQ$16);
        }
    }
    
    /**
     * Sets array of all "INTRASYNCRQ" element
     */
    public void setINTRASYNCRQArray(net.ofx.types.x2003.x04.IntraSyncRequest[] intrasyncrqArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(intrasyncrqArray, INTRASYNCRQ$16);
        }
    }
    
    /**
     * Sets ith "INTRASYNCRQ" element
     */
    public void setINTRASYNCRQArray(int i, net.ofx.types.x2003.x04.IntraSyncRequest intrasyncrq)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.IntraSyncRequest target = null;
            target = (net.ofx.types.x2003.x04.IntraSyncRequest)get_store().find_element_user(INTRASYNCRQ$16, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(intrasyncrq);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "INTRASYNCRQ" element
     */
    public net.ofx.types.x2003.x04.IntraSyncRequest insertNewINTRASYNCRQ(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.IntraSyncRequest target = null;
            target = (net.ofx.types.x2003.x04.IntraSyncRequest)get_store().insert_element_user(INTRASYNCRQ$16, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "INTRASYNCRQ" element
     */
    public net.ofx.types.x2003.x04.IntraSyncRequest addNewINTRASYNCRQ()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.IntraSyncRequest target = null;
            target = (net.ofx.types.x2003.x04.IntraSyncRequest)get_store().add_element_user(INTRASYNCRQ$16);
            return target;
        }
    }
    
    /**
     * Removes the ith "INTRASYNCRQ" element
     */
    public void removeINTRASYNCRQ(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(INTRASYNCRQ$16, i);
        }
    }
    
    /**
     * Gets array of all "RECINTRASYNCRQ" elements
     */
    public net.ofx.types.x2003.x04.RecurringIntraSyncRequest[] getRECINTRASYNCRQArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(RECINTRASYNCRQ$18, targetList);
            net.ofx.types.x2003.x04.RecurringIntraSyncRequest[] result = new net.ofx.types.x2003.x04.RecurringIntraSyncRequest[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "RECINTRASYNCRQ" element
     */
    public net.ofx.types.x2003.x04.RecurringIntraSyncRequest getRECINTRASYNCRQArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.RecurringIntraSyncRequest target = null;
            target = (net.ofx.types.x2003.x04.RecurringIntraSyncRequest)get_store().find_element_user(RECINTRASYNCRQ$18, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "RECINTRASYNCRQ" element
     */
    public int sizeOfRECINTRASYNCRQArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(RECINTRASYNCRQ$18);
        }
    }
    
    /**
     * Sets array of all "RECINTRASYNCRQ" element
     */
    public void setRECINTRASYNCRQArray(net.ofx.types.x2003.x04.RecurringIntraSyncRequest[] recintrasyncrqArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(recintrasyncrqArray, RECINTRASYNCRQ$18);
        }
    }
    
    /**
     * Sets ith "RECINTRASYNCRQ" element
     */
    public void setRECINTRASYNCRQArray(int i, net.ofx.types.x2003.x04.RecurringIntraSyncRequest recintrasyncrq)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.RecurringIntraSyncRequest target = null;
            target = (net.ofx.types.x2003.x04.RecurringIntraSyncRequest)get_store().find_element_user(RECINTRASYNCRQ$18, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(recintrasyncrq);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "RECINTRASYNCRQ" element
     */
    public net.ofx.types.x2003.x04.RecurringIntraSyncRequest insertNewRECINTRASYNCRQ(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.RecurringIntraSyncRequest target = null;
            target = (net.ofx.types.x2003.x04.RecurringIntraSyncRequest)get_store().insert_element_user(RECINTRASYNCRQ$18, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "RECINTRASYNCRQ" element
     */
    public net.ofx.types.x2003.x04.RecurringIntraSyncRequest addNewRECINTRASYNCRQ()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.RecurringIntraSyncRequest target = null;
            target = (net.ofx.types.x2003.x04.RecurringIntraSyncRequest)get_store().add_element_user(RECINTRASYNCRQ$18);
            return target;
        }
    }
    
    /**
     * Removes the ith "RECINTRASYNCRQ" element
     */
    public void removeRECINTRASYNCRQ(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(RECINTRASYNCRQ$18, i);
        }
    }
}
